Register PickleSerializer through the standard Metaflow plugin
mechanism so extensions (e.g., mli-metaflow-custom) can add their
own serializers via ARTIFACT_SERIALIZERS_DESC.

- Add artifact_serializer category to _plugin_categories
- Add ARTIFACT_SERIALIZERS_DESC with PickleSerializer in plugins/__init__.py
- Resolve via ARTIFACT_SERIALIZERS = resolve_plugins("artifact_serializer")

Importing metaflow.plugins now triggers PickleSerializer registration
in SerializerStore, ensuring the registry is populated before
TaskDataStore needs it (commit 3).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

save_artifacts now loops through priority-ordered serializers to find
one that can_serialize the object. load_artifacts routes deserialization
through metadata.encoding via can_deserialize. PickleSerializer handles
all existing Python objects as the universal fallback.

Behavioral changes:
- New artifacts get encoding "pickle-v4" (was "gzip+pickle-v4")
- _info[name] gains optional "serializer_info" dict for custom serializers
- Removed hardcoded pickle import from task_datastore.py

Backward compatible:
- Old artifacts with "gzip+pickle-v2" or "gzip+pickle-v4" encoding
  load correctly (PickleSerializer.can_deserialize handles both)
- Missing encoding defaults to "gzip+pickle-v2"
- Missing serializer_info defaults to {}
- _objects[name] stays as single string (multi-blob deferred to PR 1.5)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

- SerializerStore now extends ABCMeta (not type) so @AbstractMethod
  is enforced — incomplete subclasses raise TypeError at definition
- Validate blobs non-empty before accessing blobs[0] in save_artifacts
- Add NOTE on compress_method not yet wired into save path

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

On top of Netflix#3117, this ships the typed-artifact layer. Scope kept
deliberately small:

- ``IOType`` ABC — the contract extension authors target.
- ``Json`` and ``Struct`` — two concrete types with clear standalone
  value in core: wire format for CLI/IPC, cross-language JSON bytes
  on storage, no pickle code-execution risk. ``Struct`` also walks
  directly-nested ``@dataclass`` fields so ``Outer(inner=Inner(...))``
  round-trips back to its original type (generic containers like
  ``List[Inner]`` come back as raw JSON values — wrap those
  explicitly when you need richer reconstruction).
- ``IOTypeSerializer`` — the bridge that plugs any ``IOType`` instance
  into the ``ArtifactSerializer`` dispatch added by Netflix#3117 so save/load
  through the datastore just works.

What's intentionally *not* in this PR

- Primitive wrappers (Int32/Int64/Float32/Float64/Bool/Text). Standard
  Python numbers and strings flow through ``PickleSerializer``
  unchanged. Wrapping is opt-in, for cases where you want
  constraints/metadata attached.
- ``Tensor``. Pulls in numpy + byte-order/dtype opinions; belongs in an
  extension that can own those choices.
- ``List`` / ``Map`` / ``Enum``. Thin wrappers whose value over plain
  JSON is mostly schema emission — not enough on their own for core.
- Rich schema emission from ``Struct.to_spec()``. Extensions that ship
  primitive wrappers can override to emit fully-typed schemas; core
  just returns ``{"type": "struct"}``.

Contract

``serialize(format=...)`` / ``deserialize(data, format=..., **kw)``
mirror the ``ArtifactSerializer`` signature from Netflix#3117 and use the same
``WIRE`` / ``STORAGE`` constants, so one subclass owns both
representations:

- ``STORAGE`` → ``(List[SerializedBlob], metadata_dict)`` for
  persisting through the datastore.
- ``WIRE`` → ``str`` for CLI args, protobuf payloads, and
  cross-process IPC.

Subclasses implement four hooks (``_wire_serialize``,
``_wire_deserialize``, ``_storage_serialize``,
``_storage_deserialize``). Instantiating without the hooks raises
``TypeError``.

``IOTypeSerializer`` is registered via ``ARTIFACT_SERIALIZERS_DESC``
with ``PRIORITY=50`` — ahead of the default 100 so it catches
``IOType`` instances before a generic catch-all, and always ahead of
the ``PickleSerializer`` fallback (9999). It implements only
``STORAGE``; wire encoding is produced by calling
``IOType.serialize(format=WIRE)`` directly.

Safety

- ``Struct._storage_deserialize`` and ``IOTypeSerializer.deserialize``
  both require the class named in artifact metadata to be an actual
  class (``isinstance(..., type)``) before any further checks. This
  excludes module-level dataclass *instances* (``is_dataclass`` alone
  returns ``True`` for those) and other callables that could be
  invoked with attacker-controlled kwargs.
- Importing the metadata-named module can still run module-level
  side-effect code; the ``Struct`` docstring calls this out so callers
  don't load artifacts from untrusted sources.

Tests

- ``test_base.py`` — abstract instantiation, WIRE/STORAGE dispatch,
  invalid format, equality/hash, spec.
- ``test_json_type.py`` — wire and storage round-trips.
- ``test_struct_type.py`` — dataclass round-trip, dict round-trip,
  directly-nested dataclass round-trip, container-field pass-through,
  rejection of non-dataclass and dataclass-instance metadata.
- ``test_iotype_serializer.py`` — bridge
  ``can_serialize``/``can_deserialize``, round-trip through dataclass
  reconstruction, rejection of non-IOType classes in metadata, WIRE
  not supported on the bridge.

The metadata service stores only the artifact encoding string
("iotype:<type_name>"), not the full serializer_info dict. So when the
Flow client reconstructs an artifact, IOTypeSerializer.deserialize had no
iotype_module/iotype_class to import and KeyError'd.

Populate a registry via IOType.__init_subclass__ keyed by type_name, and
have IOTypeSerializer.deserialize resolve the class from the encoding
suffix first. iotype_module/iotype_class hints remain a secondary lookup
for introspecting artifacts whose owning extension isn't loaded locally.

Fixes round-trip of IOType artifacts through Flow(...).latest_run
.end_task[...].data without touching the metadata service or client
core.py.

``dataclasses.fields()`` includes fields declared with ``field(init=False,
...)``, but those are not accepted by the generated ``__init__``. Passing
them as kwargs raised ``TypeError: __init__() got an unexpected keyword
argument``. ``dataclasses.asdict`` does include them in its output, so the
storage blob carried them.

Fix: partition fields into init-eligible kwargs and post-construction
``setattr`` fields. The serialized value wins over ``__post_init__``'s
recomputation or a field default.

Adds a regression test that mutates the init=False field after
construction and verifies the mutated value survives a storage
round-trip.

The base ``IOType.__hash__`` does ``hash((type(self), self._value))``, which
raises ``TypeError`` when ``_value`` is inherently unhashable — a dict
wrapped by ``Json({...})`` or a dataclass with mutable fields (``list``,
``dict``) wrapped by ``Struct(...)``. Both are the primary ways users
create instances of these types, so the wrapper ends up mis-behaving in
any set/dict or cache keyed by artifacts.

Override ``__hash__`` on both subclasses to hash the canonical JSON
representation (already produced by the wire/storage path). This is:

- Stable — ``sort_keys=True`` makes the JSON deterministic across equal
  dicts/dataclasses regardless of key insertion order.
- Contract-safe — ``__eq__`` compares raw values; equal values flatten to
  identical sorted-key JSON, so ``a == b`` implies ``hash(a) == hash(b)``.
- Descriptor-aware — when ``_value is _UNSET`` (no value, pure type
  descriptor), fall back to hashing the sentinel directly.

Adds regression tests covering ``Json({...})``, ``Json([...])``,
``Struct(dc_with_list)``, plain ``Struct({...})``, and the ``Struct()``
descriptor.

Self-review before pushing caught two subtle regressions in the prior two
commits:

1. ``_reconstruct`` used plain ``setattr`` to restore ``init=False`` fields
   after construction, which raises ``FrozenInstanceError`` on
   ``@dataclass(frozen=True)``. Switch to ``object.__setattr__`` — the same
   bypass frozen dataclasses themselves use in ``__post_init__``.

2. ``Json.__hash__`` / ``Struct.__hash__`` hashed the canonical JSON string.
   That renders ``1`` and ``1.0`` as distinct strings, violating the
   ``__eq__`` / ``__hash__`` contract when users mix numeric types
   (``1 == 1.0 == True`` in Python, but ``hash('1') != hash('1.0')``).
   Replace with a recursive ``_make_hashable`` that converts dicts to
   ``frozenset`` of items and lists to ``tuple``s. Python's built-in
   hashing then collapses ``1 == 1.0 == True`` to the same bucket, and
   equal wrapped values produce equal hashes.

``_make_hashable`` lives in ``base.py`` so any future IOType wrapping
unhashable values can reuse it.

Regression tests added for:
- Frozen dataclass with ``init=False`` field round-trip.
- ``Json({'x': 1}) == Json({'x': 1.0})`` and ``hash()`` equality.
- Same for ``Struct({'x': 1})`` / ``Struct({'x': 1.0})``.
- ``Json({'x': True}) == Json({'x': 1})`` hash equality.
- ``Json([1, 2, 3]) == Json([1.0, 2.0, 3.0])`` hash equality.